import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 方法引用：  类（或对象）::方法名
 * 使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
 * 使用要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同
 * 1.对象::非静态方法
 * 2.类::静态方法
 * 3.类::非静态方法
 */
public class LambdaTest02 {
    @Test
    public void test01(){
        //对象::非静态方法
        //Consumer接口中void accept(T t);   函数式接口的方法
        //PrintStream类中public void println(T t)   某个类中的方法
        Consumer<String> consumer1=s -> System.out.println(s);
        consumer1.accept("Lambda表达式");
        System.out.println("---------------------------");
        PrintStream printStream=System.out;
        Consumer<String> consumer2=printStream::println;
        Consumer<String> consumer3=System.out::println;
        consumer3.accept("方法引用---->对象::非静态方法");
    }

    @Test
    public void test02(){
        //Supplier中 T get()
        //Employee中String getName()
        Employee employee=new Employee("tom",16,"男");
        Supplier<String> sup=()-> employee.getName();
        Supplier<String> sup2=employee::getName;
        System.out.println(sup2.get());
        System.out.println(sup.get());
    }

    @Test
    public void test03(){
        //类::静态方法
        //Comparator  int compare(T t1,T t2)
        //Integer int compare(T t1,T t2)
        Comparator<Integer> comparator=(t1,t2)->Integer.compare(t1,t2);
        System.out.println(comparator.compare(15,20));
        Comparator<Integer> comparator1=Integer::compare;
        System.out.println(comparator1.compare(55, 30));
    }


    @Test
    public void test04(){
        //类::非静态方法
        //Comparator int compare(T t1,T t2)
        //String int t1.compareTo(t2)
        Comparator<String> comparator=(s1,s2)->s1.compareTo(s2);
        System.out.println(comparator.compare("acs","ssg"));
        System.out.println("-----------------------------");
        Comparator<String> comparator1=String::compareTo;
        System.out.println(comparator1.compare("acs","ssg"));
    }

    @Test
    public void test05(){
        //Function<T, R> 中---------> R apply(T t);
        //Employee(String name, int age, String sex) 中--------------> String getName()
        //T相当于Employee，t相当于Employee的一个对象，Employee用它的t对象来调用方法
        Employee employee=new Employee("jr",15,"男");
        /*Function接口 new出function对象，apply方法返回值是employee1.getName */
        Function<Employee,String> function= employee1 -> employee1.getName();
        /* 通过function对象调用apply方法,将employee对象传入，则可得到employee对象姓名*/
        System.out.println(function.apply(employee));

        System.out.println("--------------------------------");
        /*传入的第一个参数作为方法的调用者，Employee用它的t对象来调用方法*/
        Function<Employee,String> function1=Employee::getName;
        System.out.println(function.apply(employee));
    }
}
